}
/* Convert jiffies to system time. */
-static inline u64 jiffies_to_st(unsigned long j)
+u64 jiffies_to_st(unsigned long j)
{
unsigned long seq;
long delta;
return st;
}
+EXPORT_SYMBOL(jiffies_to_st);
/*
* stop_hz_timer / start_hz_timer - enter/exit 'tickless mode' on an idle cpu
{
int err = 0;
struct xen_pci_op *active_op = &pdev->sh_info->op;
- unsigned long irq_flags;
-
- unsigned int volatile ttl = (1U << 29);
+ unsigned long irq_flags, poll_end;
+ evtchn_port_t port = pdev->evtchn;
spin_lock_irqsave(&pdev->sh_info_lock, irq_flags);
/* Go */
wmb();
set_bit(_XEN_PCIF_active, (unsigned long *)&pdev->sh_info->flags);
- notify_remote_via_evtchn(pdev->evtchn);
-
- /* IRQs are disabled for the pci config. space reads/writes,
- * which means no event channel to notify us that the backend
- * is done so spin while waiting for the answer */
- while (test_bit
- (_XEN_PCIF_active, (unsigned long *)&pdev->sh_info->flags)) {
- if (!ttl) {
+ notify_remote_via_evtchn(port);
+
+ poll_end = jiffies + 5*HZ;
+ clear_evtchn(port);
+
+ while (test_bit(_XEN_PCIF_active,
+ (unsigned long *)&pdev->sh_info->flags)) {
+ if (HYPERVISOR_poll(&port, 1, poll_end))
+ BUG();
+ clear_evtchn(port);
+ if (time_after(jiffies, poll_end)) {
dev_err(&pdev->xdev->dev,
"pciback not responding!!!\n");
clear_bit(_XEN_PCIF_active,
err = XEN_PCI_ERR_dev_not_found;
goto out;
}
- ttl--;
}
memcpy(op, active_op, sizeof(struct xen_pci_op));
#include <xen/interface/xen.h>
#include <xen/interface/sched.h>
#include <xen/interface/nmi.h>
+#include <linux/errno.h>
#define __STR(x) #x
#define STR(x) __STR(x)
return _hypercall2(int, sched_op, cmd, arg);
}
+static inline int
+HYPERVISOR_sched_op_new(
+ int cmd, void *arg)
+{
+ return _hypercall2(int, sched_op_new, cmd, arg);
+}
+
+static inline int
+HYPERVISOR_poll(
+ evtchn_port_t *ports, unsigned int nr_ports, u64 timeout)
+{
+ struct sched_poll sched_poll = {
+ .ports = ports,
+ .nr_ports = nr_ports,
+ .timeout = jiffies_to_st(timeout)
+ };
+
+ int rc = HYPERVISOR_sched_op_new(SCHEDOP_poll, &sched_poll);
+
+ if (rc == -ENOSYS)
+ rc = HYPERVISOR_sched_op(SCHEDOP_yield, 0);
+
+ return rc;
+}
+
static inline long
HYPERVISOR_set_timer_op(
u64 timeout)
void xen_destroy_contiguous_region(
unsigned long vstart, unsigned int order);
+/* Turn jiffies into Xen system time. */
+u64 jiffies_to_st(unsigned long jiffies);
+
#include <asm/hypercall.h>
#if defined(CONFIG_X86_64)
#include <xen/interface/xen.h>
#include <xen/interface/sched.h>
+#include <linux/errno.h>
/* FIXME: temp place to hold these page related macros */
#include <asm/page.h>
return _hypercall2(int, sched_op, cmd, arg);
}
+static inline int
+HYPERVISOR_sched_op_new(
+ int cmd, void *arg)
+{
+ return _hypercall2(int, sched_op_new, cmd, arg);
+}
+
+static inline int
+HYPERVISOR_poll(
+ evtchn_port_t *ports, unsigned int nr_ports, unsigned long timeout)
+{
+ struct sched_poll sched_poll = {
+ .ports = ports,
+ .nr_ports = nr_ports,
+ .timeout = jiffies_to_st(timeout)
+ };
+
+ int rc = HYPERVISOR_sched_op_new(SCHEDOP_poll, &sched_poll);
+
+ if (rc == -ENOSYS)
+ rc = HYPERVISOR_sched_op(SCHEDOP_yield, 0);
+
+ return rc;
+}
+
static inline long
HYPERVISOR_set_timer_op(
u64 timeout)
void force_evtchn_callback(void);
+/* Turn jiffies into Xen system time. XXX Implement me. */
+#define jiffies_to_st(j) 0
+
#include <asm/hypercall.h>
// for drivers/xen/privcmd/privcmd.c
#include <xen/interface/xen.h>
#include <xen/interface/sched.h>
#include <xen/interface/nmi.h>
+#include <linux/errno.h>
#define __STR(x) #x
#define STR(x) __STR(x)
return _hypercall2(int, sched_op, cmd, arg);
}
+static inline int
+HYPERVISOR_sched_op_new(
+ int cmd, void *arg)
+{
+ return _hypercall2(int, sched_op_new, cmd, arg);
+}
+
+static inline int
+HYPERVISOR_poll(
+ evtchn_port_t *ports, unsigned int nr_ports, u64 timeout)
+{
+ struct sched_poll sched_poll = {
+ .ports = ports,
+ .nr_ports = nr_ports,
+ .timeout = jiffies_to_st(timeout)
+ };
+
+ int rc = HYPERVISOR_sched_op_new(SCHEDOP_poll, &sched_poll);
+
+ if (rc == -ENOSYS)
+ rc = HYPERVISOR_sched_op(SCHEDOP_yield, 0);
+
+ return rc;
+}
+
static inline long
HYPERVISOR_set_timer_op(
u64 timeout)
movl %eax,UREGS_eax(%ecx)
jmp do_sched_op
+do_arch_sched_op_new:
+ # Ensure we return success even if we return via schedule_tail()
+ xorl %eax,%eax
+ GET_GUEST_REGS(%ecx)
+ movl %eax,UREGS_eax(%ecx)
+ jmp do_sched_op_new
+
.data
ENTRY(exception_table)
.long do_mmuext_op
.long do_acm_op
.long do_nmi_op
+ .long do_arch_sched_op_new
.rept NR_hypercalls-((.-hypercall_table)/4)
.long do_ni_hypercall
.endr
.byte 4 /* do_mmuext_op */
.byte 1 /* do_acm_op */
.byte 2 /* do_nmi_op */
+ .byte 2 /* do_arch_sched_op_new */
.rept NR_hypercalls-(.-hypercall_args_table)
.byte 0 /* do_ni_hypercall */
.endr
movq %rax,UREGS_rax(%r10)
jmp do_sched_op
+do_arch_sched_op_new:
+ # Ensure we return success even if we return via schedule_tail()
+ xorl %eax,%eax
+ GET_GUEST_REGS(%r10)
+ movq %rax,UREGS_rax(%r10)
+ jmp do_sched_op_new
+
.data
ENTRY(exception_table)
.quad do_mmuext_op
.quad do_acm_op
.quad do_nmi_op
+ .quad do_arch_sched_op_new
.rept NR_hypercalls-((.-hypercall_table)/8)
.quad do_ni_hypercall
.endr
.byte 4 /* do_mmuext_op */
.byte 1 /* do_acm_op */
.byte 2 /* do_nmi_op */
+ .byte 2 /* do_arch_sched_op_new */
.rept NR_hypercalls-(.-hypercall_args_table)
.byte 0 /* do_ni_hypercall */
.endr
return ret;
}
+void evtchn_set_pending(struct vcpu *v, int port)
+{
+ struct domain *d = v->domain;
+ shared_info_t *s = d->shared_info;
+
+ /*
+ * The following bit operations must happen in strict order.
+ * NB. On x86, the atomic bit operations also act as memory barriers.
+ * There is therefore sufficiently strict ordering for this architecture --
+ * others may require explicit memory barriers.
+ */
+
+ if ( test_and_set_bit(port, &s->evtchn_pending[0]) )
+ return;
+
+ if ( !test_bit (port, &s->evtchn_mask[0]) &&
+ !test_and_set_bit(port / BITS_PER_LONG,
+ &v->vcpu_info->evtchn_pending_sel) &&
+ !test_and_set_bit(0, &v->vcpu_info->evtchn_upcall_pending) )
+ {
+ evtchn_notify(v);
+ }
+ else if ( unlikely(test_bit(_VCPUF_blocked, &v->vcpu_flags) &&
+ v->vcpu_info->evtchn_upcall_mask) )
+ {
+ /*
+ * Blocked and masked will usually mean that the VCPU executed
+ * SCHEDOP_poll. Kick the VCPU in case this port is in its poll list.
+ */
+ vcpu_unblock(v);
+ }
+}
+
+void send_guest_virq(struct vcpu *v, int virq)
+{
+ int port = v->virq_to_evtchn[virq];
+
+ if ( likely(port != 0) )
+ evtchn_set_pending(v, port);
+}
+
void send_guest_pirq(struct domain *d, int pirq)
{
int port = d->pirq_to_evtchn[pirq];
#include <xen/softirq.h>
#include <xen/trace.h>
#include <xen/mm.h>
+#include <xen/guest_access.h>
#include <public/sched.h>
#include <public/sched_ctl.h>
static void s_timer_fn(void *unused);
static void t_timer_fn(void *unused);
static void dom_timer_fn(void *data);
+static void poll_timer_fn(void *data);
/* This is global for now so that private implementations can reach it */
struct schedule_data schedule_data[NR_CPUS];
void sched_add_domain(struct vcpu *v)
{
- /* Initialise the per-domain timer. */
+ /* Initialise the per-domain timers. */
init_timer(&v->timer, dom_timer_fn, v, v->processor);
+ init_timer(&v->poll_timer, poll_timer_fn, v, v->processor);
if ( is_idle_vcpu(v) )
{
void sched_rem_domain(struct vcpu *v)
{
kill_timer(&v->timer);
+ kill_timer(&v->poll_timer);
+
SCHED_OP(rem_task, v);
TRACE_2D(TRC_SCHED_DOM_REM, v->domain->domain_id, v->vcpu_id);
}
return 0;
}
+static long do_poll(struct sched_poll *sched_poll)
+{
+ struct vcpu *v = current;
+ evtchn_port_t port;
+ long rc = 0;
+ unsigned int i;
+
+ /* Fairly arbitrary limit. */
+ if ( sched_poll->nr_ports > 128 )
+ return -EINVAL;
+
+ if ( !guest_handle_okay(sched_poll->ports, sched_poll->nr_ports) )
+ return -EFAULT;
+
+ /* Ensure that upcalls are disabled: tested by evtchn_set_pending(). */
+ if ( !v->vcpu_info->evtchn_upcall_mask )
+ return -EINVAL;
+
+ set_bit(_VCPUF_blocked, &v->vcpu_flags);
+
+ /* Check for events /after/ blocking: avoids wakeup waiting race. */
+ for ( i = 0; i < sched_poll->nr_ports; i++ )
+ {
+ rc = -EFAULT;
+ if ( __copy_from_guest_offset(&port, sched_poll->ports, i, 1) )
+ goto out;
+
+ rc = -EINVAL;
+ if ( port >= MAX_EVTCHNS )
+ goto out;
+
+ rc = 0;
+ if ( evtchn_pending(v->domain, port) )
+ goto out;
+ }
+
+ if ( sched_poll->timeout != 0 )
+ set_timer(&v->poll_timer, sched_poll->timeout);
+
+ TRACE_2D(TRC_SCHED_BLOCK, v->domain->domain_id, v->vcpu_id);
+ __enter_scheduler();
+
+ stop_timer(&v->poll_timer);
+
+ out:
+ clear_bit(_VCPUF_blocked, &v->vcpu_flags);
+ return rc;
+}
+
/* Voluntarily yield the processor for this allocation. */
static long do_yield(void)
{
return ret;
}
+long do_sched_op_new(int cmd, GUEST_HANDLE(void) arg)
+{
+ long ret = 0;
+
+ switch ( cmd )
+ {
+ case SCHEDOP_yield:
+ {
+ ret = do_yield();
+ break;
+ }
+
+ case SCHEDOP_block:
+ {
+ ret = do_block();
+ break;
+ }
+
+ case SCHEDOP_shutdown:
+ {
+ struct sched_shutdown sched_shutdown;
+
+ ret = -EFAULT;
+ if ( copy_from_guest(&sched_shutdown, arg, 1) )
+ break;
+
+ ret = 0;
+ TRACE_3D(TRC_SCHED_SHUTDOWN,
+ current->domain->domain_id, current->vcpu_id,
+ sched_shutdown.reason);
+ domain_shutdown(current->domain, (u8)sched_shutdown.reason);
+
+ break;
+ }
+
+ case SCHEDOP_poll:
+ {
+ struct sched_poll sched_poll;
+
+ ret = -EFAULT;
+ if ( copy_from_guest(&sched_poll, arg, 1) )
+ break;
+
+ ret = do_poll(&sched_poll);
+
+ break;
+ }
+
+ default:
+ ret = -ENOSYS;
+ }
+
+ return ret;
+}
+
/* Per-domain one-shot-timer hypercall. */
long do_set_timer_op(s_time_t timeout)
{
send_guest_virq(v, VIRQ_TIMER);
}
+/* SCHEDOP_poll timeout callback. */
+static void poll_timer_fn(void *data)
+{
+ struct vcpu *v = data;
+ vcpu_unblock(v);
+}
+
/* Initialise the data structures. */
void __init scheduler_init(void)
{
#define __XEN_PUBLIC_EVENT_CHANNEL_H__
typedef uint32_t evtchn_port_t;
+DEFINE_GUEST_HANDLE(evtchn_port_t);
/*
* EVTCHNOP_alloc_unbound: Allocate a port in domain <dom> and mark as
#ifndef __XEN_PUBLIC_SCHED_H__
#define __XEN_PUBLIC_SCHED_H__
+#include "event_channel.h"
+
/*
- * Prototype for this hypercall is:
- * int sched_op(int cmd, unsigned long arg)
+ * There are two forms of this hypercall.
+ *
+ * The first and preferred version is only available from Xen 3.0.2.
+ * The prototype for this hypercall is:
+ * long sched_op_new(int cmd, void *arg)
+ * @cmd == SCHEDOP_??? (scheduler operation).
+ * @arg == Operation-specific extra argument(s), as described below.
+ *
+ * The legacy version of this hypercall supports only the following commands:
+ * SCHEDOP_yield, SCHEDOP_block, and SCHEDOP_shutdown. The prototype for the
+ * legacy hypercall is:
+ * long sched_op(int cmd, unsigned long arg)
* @cmd == SCHEDOP_??? (scheduler operation).
- * @arg == Operation-specific extra argument(s).
+ * @arg == 0 (SCHEDOP_yield and SCHEDOP_block)
+ * == SHUTDOWN_* code (SCHEDOP_shutdown)
+ *
+ * The sub-command descriptions below describe extra arguments for the
+ * sched_op_new() hypercall.
*/
/*
* Voluntarily yield the CPU.
- * @arg == 0.
+ * @arg == NULL.
*/
#define SCHEDOP_yield 0
* If called with event upcalls masked, this operation will atomically
* reenable event delivery and check for pending events before blocking the
* VCPU. This avoids a "wakeup waiting" race.
- * @arg == 0.
+ * @arg == NULL.
*/
#define SCHEDOP_block 1
/*
* Halt execution of this domain (all VCPUs) and notify the system controller.
- * @arg == SHUTDOWN_??? (reason for shutdown).
+ * @arg == pointer to sched_shutdown structure.
*/
#define SCHEDOP_shutdown 2
+typedef struct sched_shutdown {
+ unsigned int reason; /* SHUTDOWN_* */
+} sched_shutdown_t;
+DEFINE_GUEST_HANDLE(sched_shutdown_t);
+
+/*
+ * Poll a set of event-channel ports. Return when one or more are pending. An
+ * optional timeout may be specified.
+ * @arg == pointer to sched_poll structure.
+ */
+#define SCHEDOP_poll 3
+typedef struct sched_poll {
+ GUEST_HANDLE(evtchn_port_t) ports;
+ unsigned int nr_ports;
+ uint64_t timeout;
+} sched_poll_t;
+DEFINE_GUEST_HANDLE(sched_poll_t);
/*
- * Reason codes for SCHEDOP_shutdown. These may be interpreted by controller
+ * Reason codes for SCHEDOP_shutdown. These may be interpreted by control
* software to determine the appropriate action. For the most part, Xen does
* not care about the shutdown code.
*/
#define __HYPERVISOR_mmuext_op 26
#define __HYPERVISOR_acm_op 27
#define __HYPERVISOR_nmi_op 28
+#define __HYPERVISOR_sched_op_new 29
/*
* VIRTUAL INTERRUPTS
#include <asm/bitops.h>
#include <asm/event.h>
-/*
- * EVENT-CHANNEL NOTIFICATIONS
- * NB. On x86, the atomic bit operations also act as memory barriers. There
- * is therefore sufficiently strict ordering for this architecture -- others
- * may require explicit memory barriers.
- */
-
-static inline void evtchn_set_pending(struct vcpu *v, int port)
-{
- struct domain *d = v->domain;
- shared_info_t *s = d->shared_info;
-
- /* These four operations must happen in strict order. */
- if ( !test_and_set_bit(port, &s->evtchn_pending[0]) &&
- !test_bit (port, &s->evtchn_mask[0]) &&
- !test_and_set_bit(port / BITS_PER_LONG,
- &v->vcpu_info->evtchn_pending_sel) &&
- !test_and_set_bit(0, &v->vcpu_info->evtchn_upcall_pending) )
- {
- evtchn_notify(v);
- }
-}
+extern void evtchn_set_pending(struct vcpu *v, int port);
/*
* send_guest_virq:
* @v: VCPU to which virtual IRQ should be sent
* @virq: Virtual IRQ number (VIRQ_*)
*/
-static inline void send_guest_virq(struct vcpu *v, int virq)
-{
- int port = v->virq_to_evtchn[virq];
-
- if ( likely(port != 0) )
- evtchn_set_pending(v, port);
-}
+extern void send_guest_virq(struct vcpu *v, int virq);
/*
* send_guest_pirq:
(!!(v)->vcpu_info->evtchn_upcall_pending & \
!(v)->vcpu_info->evtchn_upcall_mask)
+#define evtchn_pending(d, p) \
+ (test_bit((p), &(d)->shared_info->evtchn_pending[0]))
+
/* Send a notification from a local event-channel port. */
extern long evtchn_send(unsigned int lport);
struct timer timer; /* one-shot timer for timeout values */
unsigned long sleep_tick; /* tick at which this vcpu started sleep */
+ struct timer poll_timer; /* timeout for SCHEDOP_poll */
+
void *sched_priv; /* scheduler-specific data */
struct vcpu_runstate_info runstate;
projects / xen.git / commitdiff